package com.hnas.core.app_common.util;

public class ConvertUtil {
	private final static char[] HEX = { '0', '1', '2', '3', '4', '5', '6', '7',
			'8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

	private ConvertUtil() {
	}

	/*
	 * 将整型数据转换为HEX字节码 如 :200转换为000000C8
	 */
	public static byte[] toBytes(int a) {
		return new byte[] { (byte) (0x000000ff & (a >>> 24)),
				(byte) (0x000000ff & (a >>> 16)),
				(byte) (0x000000ff & (a >>> 8)), (byte) (0x000000ff & (a)) };
	}

	// ************************************
	// 函数功能: 16进制数组值转为整型
	// 函数全名: HexToInt
	// 作 者: 陶志高
	// 访问权限: public
	// 返回类型: TXTCONVERSIONE_API BOOL WINAPI
	// 参数说明: char * pHex 如：0x1A2B,最多4字节
	// 参数说明: int * intVal 转换后的int值6699
	// 参数说明: int hexlen
	/*
	 * 将b的startpos开始的连续nbytes字节转换为INT数据 如：000000C8转换为200
	 */
	// ************************************
	public static int toInt(byte[] b, int startpos, int nbytes) {
		int ret = 0;
		final int endpos = startpos + nbytes;
		for (int i = startpos; i < endpos; ++i) {
			ret <<= 8;
			ret |= b[i] & 0xFF;
		}
		return ret;
	}

	/*
	 * 将b的startpos结束的连续nbytes字节转换为INT数据(b中的整型数据是高低字节倒序的) 如：000000C8转换为200
	 */
	public static int toIntR(byte[] b, int s, int n) {
		int ret = 0;
		for (int i = s; (i >= 0 && n > 0); --i, --n) {
			ret <<= 8;
			ret |= b[i] & 0xFF;
		}
		return ret;
	}

	/*
 * */
	public static int toInt(byte... b) {
		int ret = 0;
		for (final byte a : b) {
			ret <<= 8;
			ret |= a & 0xFF;
		}
		return ret;
	}

	/*
	 * nbytes d的长度 startpos d中要转换为字符串的字节起始位置 start
	 */
	public static String toHexString(byte[] d, int startpos, int nbytes) {
		final char[] ret = new char[nbytes * 2];
		final int endpos = startpos + nbytes;
		int x = 0;
		for (int i = startpos; i < endpos; ++i) {
			final byte v = d[i];
			ret[x++] = HEX[0x0F & (v >> 4)];
			ret[x++] = HEX[0x0F & v];
		}
		return new String(ret);
	}

	public static String toHexStringR(byte[] d, int s, int n) {
		final char[] ret = new char[n * 2];

		int x = 0;
		for (int i = s + n - 1; i >= s; --i) {
			final byte v = d[i];
			ret[x++] = HEX[0x0F & (v >> 4)];
			ret[x++] = HEX[0x0F & v];
		}
		return new String(ret);
	}

	public static int parseInt(String txt, int radix, int def) {
		int ret;
		try {
			ret = Integer.valueOf(txt, radix);
		} catch (Exception e) {
			ret = def;
		}
		return ret;
	}

	public static String toAmountString(float value) {
		return String.format("%.2f", value);
	}

	public static String toBcdCardno(String cardno) {
		String cardnoafter = cardno.substring(8);
		while (cardnoafter.substring(0, 1).equals("0")) {
			cardnoafter = cardnoafter.substring(1);
		}
		String bcdcard = String.valueOf(Integer.parseInt(cardnoafter + "", 16));
		while (bcdcard.length() < 8) {
			bcdcard = "0" + bcdcard;
		}
		return cardno.substring(0, 8) + bcdcard;
	}

	public static String toHexCardno(String cardno) {
		String cardnoafter = cardno.substring(8);
		while (cardnoafter.substring(0, 1).equals("0")) {
			cardnoafter = cardnoafter.substring(1);
		}
		String bcdcard = String.valueOf(Integer.parseInt(cardnoafter + "", 16));
		while (bcdcard.length() < 8) {
			bcdcard = "0" + bcdcard;
		}
		return cardno.substring(0, 8) + bcdcard;
	}

	// ///////////////////////////////////////////////////////
	// ************************************
	// 功 能: 将一个十六进制字节串转换成 ASCII 码表示的字符串
	// 函 数 名: HexToAscii
	// 返 回 值: void
	// 作 者： 陶志高
	// 参 数: unsigned char * pHex 要转换的十六进制数字节串首地址
	// 参 数: unsigned char * pAscii 转换后的 ASCII 码表示的字符串的首地址
	// 参 数: int nHexLen 要转换的十六进制数的长度（字节数）
	// 说明 不对数组越界进行检查 例: "\x12\x34\x56\x78"->"12345678" nHexLen=4 转换后8字节
	// ************************************
	public static void HexToAscii(byte[] pHex, byte[] pAscii, int nHexLen) {
		byte curChar;
		for (int nChar = 0; nChar < nHexLen; ++nChar) {
			// 高四字节
			curChar = (byte) ((pHex[nChar] & 0xF0) >> 4);
			if (curChar >= 0x00 && curChar <= 0x09) {
				// 0-9
				pAscii[nChar * 2] = (byte) (curChar + 0x30);
			}
			if (curChar >= 0x0A) {
				// A-F
				pAscii[nChar * 2] = (byte) (curChar + 0x37);
			}
			// 低四字节
			curChar = (byte) (pHex[nChar] & 0x0F);
			if (curChar >= 0x00 && curChar <= 0x09) {
				// 0-9
				pAscii[nChar * 2 + 1] = (byte) (curChar + 0x30);
			}
			if (curChar >= 0x0A) {
				// A-F
				pAscii[nChar * 2 + 1] = (byte) (curChar + 0x37);
			}
		}
	}

	// ************************************
	// 功 能: 将一个 ASCII 码表示的十六进制字符串转换成十六进制的字节串(值)
	// 函 数 名: AsciiToHex
	// 返 回 值: BOOL 不是0-9 A-F a-f返回FALSE
	// 作 者： 陶志高
	// 参 数: unsigned char * pAscii 要转换的 ASCII 码表示的十六进制字符串的首地址
	// 参 数: unsigned char * pHex 转换后的十六进制数字节串首地址
	// 参 数: int nASCLen 要转换的 ASCII 码表示的十六进制字符串的长度（字节数）
	// 说明：自动去掉空格，不对数组越界进行检查, 例 "12 34 5678"->"\x12\x34\x56\x78" nlen=8 转换后4字节
	// ************************************
	public static boolean AsciiToHex(byte[] pAscii, byte[] pHex, int nASCLen) {
		byte curChar;
		int nHex = 0, nSpace = 0;
		boolean bHight = false;
		for (int nChar = 0; nChar < nASCLen; ++nChar) {
			// 第N个字符
			curChar = pAscii[nChar];
			if (curChar == ' ') {
				// 去掉空格
				++nSpace;
				continue;
			}
			// 对应的16进制数
			nHex = (nChar - nSpace) / 2;
			bHight = (((nChar - nSpace) % 2) == 1) ? false : true;
			if (curChar >= '0' && curChar <= '9') {
				// 0-9
				if (bHight) {
					pHex[nHex] = (byte) ((curChar - 0x30) << 4);
				} else {
					pHex[nHex] = (byte) (pHex[nHex] + curChar - 0x30);
				}
				continue;
			}
			if (curChar >= 'a' && curChar <= 'f') {
				// a-f
				if (bHight) {
					pHex[nHex] = (byte) ((curChar - 0x57) << 4);
				} else {
					pHex[nHex] = (byte) (pHex[nHex] + curChar - 0x57);
				}
				continue;
			}
			if (curChar >= 'A' && curChar <= 'F') {
				// A-F
				if (bHight) {
					pHex[nHex] = (byte) ((curChar - 0x37) << 4);
				} else {
					pHex[nHex] = (byte) (pHex[nHex] + curChar - 0x37);
				}
				continue;
			}
			return false;
		}
		return true;
	}

	// ************************************
	// 函数功能: 16进制字符串转为整型
	// 函数全名: HexStrToInt
	// 作 者: 陶志高
	// 访问权限: public
	// 返回类型: TXTCONVERSIONE_API BOOL WINAPI
	// 参数说明: char * pHexStr 如：“1A2B”最多8个字符，4字节
	// 参数说明: int * intVal 转换后的int值6699
	// 参数说明: int hexlen 字符串长度
	// ************************************
	public static int HexStrToInt(byte[] pHexStr, int hexlen) {
		int intVal = 0;
		byte[] pHex = new byte[4];
		if (!AsciiToHex(pHexStr, pHex, hexlen)) {
			return 0;
		}
		intVal = toInt(pHex, 0, hexlen / 2);
		return intVal;
	}

	// ************************************
	// 函数功能: 整型转为16进制数组
	// 函数全名: IntToHex
	// 作 者: 陶志高
	// 访问权限: public
	// 返回类型: TXTCONVERSIONE_API BOOL WINAPI
	// 参数说明: char * pHexSource 最多4字节,如：36转换后为0x00000024
	// 参数说明: int intVal 要转换的整数
	// 参数说明: int* hexlen
	// 转换后的HEX长度,总长度为4字节，hexlen为实际数据字节长度，如36转换后为0x00000024，hexlen＝1
	// ************************************
	public static byte[] IntToHex(int intVal) {
		return toBytes(intVal);
	}

	// ************************************
	// 函数功能: 整型转为16进制字符串
	// 函数全名: IntToHexStr
	// 作 者: 陶志高
	// 访问权限: public
	// 返回类型: TXTCONVERSIONE_API BOOL WINAPI
	// 参数说明: char * pHexStr 最多8字节,如：36转换后为0x00000024
	// 参数说明: int intVal 要转换的整数
	// 参数说明: int * hexlen 转换后的HEX长度
	// ************************************
	public static byte[] IntToHexStr(int intVal) {
		byte[] pHexStr = new byte[8];
		byte[] pHex = IntToHex(intVal);
		HexToAscii(pHex, pHexStr, 4);
		return pHexStr;
	}

	/*
	 * Convert byte[] to hex
	 * string.将byte转换成int，然后利用Integer.toHexString(int)来转换成16进制字符串。
	 * 
	 * @param src byte[] data
	 * 
	 * @return hex string
	 */
	public static String bytesToHexString(byte[] src) {
		StringBuilder stringBuilder = new StringBuilder("");
		if (src == null || src.length <= 0) {
			return null;
		}
		for (int i = 0; i < src.length; i++) {
			int v = src[i] & 0xFF;
			String hv = Integer.toHexString(v);
			if (hv.length() < 2) {
				stringBuilder.append(0);
			}
			stringBuilder.append(hv);
		}
		return stringBuilder.toString();
	}
	
	public static byte[] bytesToBcd(byte[] src){
		if (src == null || src.length <= 0) {
			return null;
		}
		byte[] result = new byte[0];
		for (int i = 0; i < src.length; i++) {
			int v = src[i] & 0xFF;
			String hv = Integer.toHexString(v);
			if (hv.length() < 2) {
				hv = 0+hv;
			}
			result = byteMerger(result,hexStringToBytes(hv));
		}
		return result;
	}

	/**
	 * Convert hex string to byte[]
	 * 
	 * @param hexString
	 *            the hex string
	 * @return byte[]
	 */
	public static byte[] hexStringToBytes(String hexString) {
		if (hexString == null || hexString.equals("")) {
			return null;
		}
		hexString = hexString.toUpperCase();
		int length = hexString.length() / 2;
		char[] hexChars = hexString.toCharArray();
		byte[] d = new byte[length];
		for (int i = 0; i < length; i++) {
			int pos = i * 2;
			d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
		}
		return d;
	}

	/**
	 * Convert char to byte
	 * 
	 * @param c
	 *            char
	 * @return byte
	 */
	public static byte charToByte(char c) {
		return (byte) "0123456789ABCDEF".indexOf(c);
	}

	// 16进制转字符串
	public static String byte2hex(byte[] data) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < data.length; i++) {
			String temp = Integer.toHexString(((int) data[i]) & 0xFF);
			for (int t = temp.length(); t < 2; t++) {
				sb.append("0");
			}
			sb.append(temp);
		}
		return sb.toString();
	}

	// 16进制转2进制
	public static byte[] hexToBytes(String str) {
		if (str == null) {
			return null;
		} else if (str.length() < 2) {
			return null;
		} else {
			int len = str.length() / 2;
			byte[] buffer = new byte[len];
			for (int i = 0; i < len; i++) {
				buffer[i] = (byte) Integer.parseInt(
						str.substring(i * 2, i * 2 + 2), 16);
			}
			return buffer;
		}
	}

	// ASCII码转换为16进制
	public static String convertStringToHex(String str) {
		char[] chars = str.toCharArray();
		StringBuffer hex = new StringBuffer();
		for (int i = 0; i < chars.length; i++) {
			hex.append(Integer.toHexString((int) chars[i]));
		}

		return hex.toString();
	}

	// 16进制转换为ASCII
	public static String convertHexToString(String hex) {
		StringBuilder sb = new StringBuilder();
		StringBuilder temp = new StringBuilder();

		// 49204c6f7665204a617661 split into two characters 49, 20, 4c...
		for (int i = 0; i < hex.length() - 1; i += 2) {

			// grab the hex in pairs
			String output = hex.substring(i, (i + 2));
			// convert hex to decimal
			int decimal = Integer.parseInt(output, 16);
			// convert the decimal to character
			sb.append((char) decimal);

			temp.append(decimal);
		}
		return sb.toString();
	}
	
	/**
	 * 字符串转acsii码
	 * @param str
	 * @return
	 */
	public static String str2Ascii(String str) {
		StringBuilder sb = new StringBuilder();
		byte[] bs = str.getBytes();
		for (int i = 0; i < bs.length; i++)
			sb.append(toHex(bs[i]));
		return sb.toString();
	}
	
	/**
	 * 整型转16进制
	 * @param n
	 * @return
	 */
    public static String toHex(int n){
        StringBuilder sb=new StringBuilder();
        if(n/16==0){
            return toHexUtil(n);
        }else{
            String t=toHex(n/16);
            int nn=n%16;
            sb.append(t).append(toHexUtil(nn));
        }
        return sb.toString();
    }
    
    /**
     * 10进制byte数组转成ascii对应的字符，然后拼接成字符串
     * @param date
     * @return
     */
    public static String decArr2String(byte[] date){
    	StringBuffer result = new StringBuffer();
    	for (byte b : date) {
    		result.append((char)b);
		}
    	return result.toString();
    }
    
    /**
	 * 将字符串才分两个字符为一组装入字节字符串数据组 如果最后一位不组两个字符，前面补0；
	 * 
	 * @param str
	 * @return
	 */
	public static String[] Str2Arr(String str) {
		int len = str.length();
		int size = 0;
		if (len % 2 != 0) {
			size = (len / 2) + 1;
		} else {
			size = len / 2;
		}
		String[] arr = new String[size];
		String content = "";
		int index = 0;
		for (int i = 0; i <= len - 1; i = i + 2) {
			content = "";
			content += str.substring(i, i + 1);
			if (!((i + 1) == len)) {
				content += str.substring(i + 1, i + 2);
			}
			arr[index] = content;
			index++;
		}
		return arr;
	}
	
	/**
	 * 将字符串数据中每一个元素的数组转成16进制，装入byte数组中
	 * 
	 * @param str
	 * @return
	 */
	public static byte[] strArr2byteArr(String[] str) {
		int len = str.length;
		byte[] content = new byte[len];
		int index = 0;
		for (String s : str) {
			if (s.length() == 1) {
				s = 0 + s;
			}
			byte[] t = hexToBytes(s);
			content[index] = t[0];
			index++;
		}
		return content;
	}
	
	/**
	 * 将连个byte合并城一个byte数组
	 * 
	 * @param byte_1
	 * @param byte_2
	 * @return
	 */
	public static byte[] byteMerger(byte byte_1, byte byte_2) {
		byte[] newByte = new byte[2];
		newByte[0] = byte_1;
		newByte[1] = byte_2;
		return newByte;
	}

	/**
	 * byte数组拼接
	 * 
	 * @param byte_1
	 * @param byte_2
	 * @return
	 */
	public static byte[] byteMerger(byte[] byte_1, byte[] byte_2) {
		byte[] newByte = new byte[byte_1.length + byte_2.length];
		System.arraycopy(byte_1, 0, newByte, 0, byte_1.length);
		System.arraycopy(byte_2, 0, newByte, byte_1.length, byte_2.length);
		return newByte;
	}

	/**
	 * byte数组拼接单个byte，生成新的数组
	 * 
	 * @param byte_1
	 * @param byte_2
	 * @return
	 */
	public static byte[] byteMerger(byte[] byte_1, byte byte_2) {
		int len = byte_1.length + 1;
		byte[] newByte = new byte[len];
		System.arraycopy(byte_1, 0, newByte, 0, byte_1.length);
		newByte[len - 1] = byte_2;
		return newByte;
	}
	
	private static String toHexUtil(int n){
        String rt="";
        switch(n){
        case 10:rt+="A";break;
        case 11:rt+="B";break;
        case 12:rt+="C";break;
        case 13:rt+="D";break;
        case 14:rt+="E";break;
        case 15:rt+="F";break;
        default:
            rt+=n;
        }
        return rt;
	}
}
